var jsonlint = function() {
    var a = !0
      , b = !1
      , c = {}
      , d = function() {
        var a = {
            trace: function() {},
            yy: {},
            symbols_: {
                error: 2,
                JSONString: 3,
                STRING: 4,
                JSONNumber: 5,
                NUMBER: 6,
                JSONNullLiteral: 7,
                NULL: 8,
                JSONBooleanLiteral: 9,
                TRUE: 10,
                FALSE: 11,
                JSONText: 12,
                JSONValue: 13,
                EOF: 14,
                JSONObject: 15,
                JSONArray: 16,
                "{": 17,
                "}": 18,
                JSONMemberList: 19,
                JSONMember: 20,
                ":": 21,
                ",": 22,
                "[": 23,
                "]": 24,
                JSONElementList: 25,
                $accept: 0,
                $end: 1
            },
            terminals_: {
                2: "error",
                4: "STRING",
                6: "NUMBER",
                8: "NULL",
                10: "TRUE",
                11: "FALSE",
                14: "EOF",
                17: "{",
                18: "}",
                21: ":",
                22: ",",
                23: "[",
                24: "]"
            },
            productions_: [0, [3, 1], [5, 1], [7, 1], [9, 1], [9, 1], [12, 2], [13, 1], [13, 1], [13, 1], [13, 1], [13, 1], [13, 1], [15, 2], [15, 3], [20, 3], [19, 1], [19, 3], [16, 2], [16, 3], [25, 1], [25, 3]],
            performAction: function(b, c, d, e, f, g, h) {
                var i = g.length - 1;
                switch (f) {
                case 1:
                    this.$ = b.replace(/\\(\\|")/g, "$1").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\v/g, "").replace(/\\f/g, "\f").replace(/\\b/g, "\b");
                    break;
                case 2:
                    this.$ = Number(b);
                    break;
                case 3:
                    this.$ = null;
                    break;
                case 4:
                    this.$ = !0;
                    break;
                case 5:
                    this.$ = !1;
                    break;
                case 6:
                    return this.$ = g[i - 1];
                case 13:
                    this.$ = {};
                    break;
                case 14:
                    this.$ = g[i - 1];
                    break;
                case 15:
                    this.$ = [g[i - 2], g[i]];
                    break;
                case 16:
                    this.$ = {},
                    this.$[g[i][0]] = g[i][1];
                    break;
                case 17:
                    this.$ = g[i - 2],
                    g[i - 2][g[i][0]] = g[i][1];
                    break;
                case 18:
                    this.$ = [];
                    break;
                case 19:
                    this.$ = g[i - 1];
                    break;
                case 20:
                    this.$ = [g[i]];
                    break;
                case 21:
                    this.$ = g[i - 2],
                    g[i - 2].push(g[i])
                }
            },
            table: [{
                3: 5,
                4: [1, 12],
                5: 6,
                6: [1, 13],
                7: 3,
                8: [1, 9],
                9: 4,
                10: [1, 10],
                11: [1, 11],
                12: 1,
                13: 2,
                15: 7,
                16: 8,
                17: [1, 14],
                23: [1, 15]
            }, {
                1: [3]
            }, {
                14: [1, 16]
            }, {
                14: [2, 7],
                18: [2, 7],
                22: [2, 7],
                24: [2, 7]
            }, {
                14: [2, 8],
                18: [2, 8],
                22: [2, 8],
                24: [2, 8]
            }, {
                14: [2, 9],
                18: [2, 9],
                22: [2, 9],
                24: [2, 9]
            }, {
                14: [2, 10],
                18: [2, 10],
                22: [2, 10],
                24: [2, 10]
            }, {
                14: [2, 11],
                18: [2, 11],
                22: [2, 11],
                24: [2, 11]
            }, {
                14: [2, 12],
                18: [2, 12],
                22: [2, 12],
                24: [2, 12]
            }, {
                14: [2, 3],
                18: [2, 3],
                22: [2, 3],
                24: [2, 3]
            }, {
                14: [2, 4],
                18: [2, 4],
                22: [2, 4],
                24: [2, 4]
            }, {
                14: [2, 5],
                18: [2, 5],
                22: [2, 5],
                24: [2, 5]
            }, {
                14: [2, 1],
                18: [2, 1],
                21: [2, 1],
                22: [2, 1],
                24: [2, 1]
            }, {
                14: [2, 2],
                18: [2, 2],
                22: [2, 2],
                24: [2, 2]
            }, {
                3: 20,
                4: [1, 12],
                18: [1, 17],
                19: 18,
                20: 19
            }, {
                3: 5,
                4: [1, 12],
                5: 6,
                6: [1, 13],
                7: 3,
                8: [1, 9],
                9: 4,
                10: [1, 10],
                11: [1, 11],
                13: 23,
                15: 7,
                16: 8,
                17: [1, 14],
                23: [1, 15],
                24: [1, 21],
                25: 22
            }, {
                1: [2, 6]
            }, {
                14: [2, 13],
                18: [2, 13],
                22: [2, 13],
                24: [2, 13]
            }, {
                18: [1, 24],
                22: [1, 25]
            }, {
                18: [2, 16],
                22: [2, 16]
            }, {
                21: [1, 26]
            }, {
                14: [2, 18],
                18: [2, 18],
                22: [2, 18],
                24: [2, 18]
            }, {
                22: [1, 28],
                24: [1, 27]
            }, {
                22: [2, 20],
                24: [2, 20]
            }, {
                14: [2, 14],
                18: [2, 14],
                22: [2, 14],
                24: [2, 14]
            }, {
                3: 20,
                4: [1, 12],
                20: 29
            }, {
                3: 5,
                4: [1, 12],
                5: 6,
                6: [1, 13],
                7: 3,
                8: [1, 9],
                9: 4,
                10: [1, 10],
                11: [1, 11],
                13: 30,
                15: 7,
                16: 8,
                17: [1, 14],
                23: [1, 15]
            }, {
                14: [2, 19],
                18: [2, 19],
                22: [2, 19],
                24: [2, 19]
            }, {
                3: 5,
                4: [1, 12],
                5: 6,
                6: [1, 13],
                7: 3,
                8: [1, 9],
                9: 4,
                10: [1, 10],
                11: [1, 11],
                13: 31,
                15: 7,
                16: 8,
                17: [1, 14],
                23: [1, 15]
            }, {
                18: [2, 17],
                22: [2, 17]
            }, {
                18: [2, 15],
                22: [2, 15]
            }, {
                22: [2, 21],
                24: [2, 21]
            }],
            defaultActions: {
                16: [2, 6]
            },
            parseError: function(b, c) {
                throw new Error(b)
            },
            parse: function(b) {
                function o(a) {
                    d.length = d.length - 2 * a,
                    e.length = e.length - a,
                    f.length = f.length - a
                }
                function p() {
                    var a;
                    return a = c.lexer.lex() || 1,
                    typeof a != "number" && (a = c.symbols_[a] || a),
                    a
                }
                var c = this
                  , d = [0]
                  , e = [null]
                  , f = []
                  , g = this.table
                  , h = ""
                  , i = 0
                  , j = 0
                  , k = 0
                  , l = 2
                  , m = 1;
                this.lexer.setInput(b),
                this.lexer.yy = this.yy,
                this.yy.lexer = this.lexer,
                typeof this.lexer.yylloc == "undefined" && (this.lexer.yylloc = {});
                var n = this.lexer.yylloc;
                f.push(n),
                typeof this.yy.parseError == "function" && (this.parseError = this.yy.parseError);
                var q, r, s, t, u, v, w = {}, x, y, z, A;
                for (; ; ) {
                    s = d[d.length - 1],
                    this.defaultActions[s] ? t = this.defaultActions[s] : (q == null && (q = p()),
                    t = g[s] && g[s][q]);
                    if (typeof t == "undefined" || !t.length || !t[0]) {
                        if (!k) {
                            // var lines = document.querySelectorAll('#editor .CodeMirror-code .CodeMirror-line ');
                            // lines[i].style.backgroundColor = '#ffe5e0';
                            A = [];
                            for (x in g[s])
                                this.terminals_[x] && x > 2 && A.push("'" + this.terminals_[x] + "'");
                            var B = "";
                            this.lexer.showPosition ? B = "第 " + (i + 1) + ' 行解析错误' + ":\n" + this.lexer.showPosition() + "\n期望是 " + A.join(", ") + ", got '" + this.terminals_[q] + "'" : B = "第 " + (i + 1) + ' 行解析错误' + ": 不期望是 " + (q == 1 ? "end of input" : "'" + (this.terminals_[q] || q) + "'"),
                            this.parseError(B, {
                                text: this.lexer.match,
                                token: this.terminals_[q] || q,
                                line: this.lexer.yylineno,
                                loc: n,
                                expected: A
                            });
                        }
                        if (k == 3) {
                            if (q == m)
                                throw new Error(B || "Parsing halted.");
                            j = this.lexer.yyleng,
                            h = this.lexer.yytext,
                            i = this.lexer.yylineno,
                            n = this.lexer.yylloc,
                            q = p()
                        }
                        for (; ; ) {
                            if (l.toString()in g[s])
                                break;
                            if (s == 0)
                                throw new Error(B || "Parsing halted.");
                            o(1),
                            s = d[d.length - 1]
                        }
                        r = q,
                        q = l,
                        s = d[d.length - 1],
                        t = g[s] && g[s][l],
                        k = 3
                    }
                    if (t[0]instanceof Array && t.length > 1)
                        throw new Error("Parse Error: multiple actions possible at state: " + s + ", token: " + q);
                    switch (t[0]) {
                    case 1:
                        d.push(q),
                        e.push(this.lexer.yytext),
                        f.push(this.lexer.yylloc),
                        d.push(t[1]),
                        q = null,
                        r ? (q = r,
                        r = null) : (j = this.lexer.yyleng,
                        h = this.lexer.yytext,
                        i = this.lexer.yylineno,
                        n = this.lexer.yylloc,
                        k > 0 && k--);
                        break;
                    case 2:
                        y = this.productions_[t[1]][1],
                        w.$ = e[e.length - y],
                        w._$ = {
                            first_line: f[f.length - (y || 1)].first_line,
                            last_line: f[f.length - 1].last_line,
                            first_column: f[f.length - (y || 1)].first_column,
                            last_column: f[f.length - 1].last_column
                        },
                        v = this.performAction.call(w, h, j, i, this.yy, t[1], e, f);
                        if (typeof v != "undefined")
                            return v;
                        y && (d = d.slice(0, -1 * y * 2),
                        e = e.slice(0, -1 * y),
                        f = f.slice(0, -1 * y)),
                        d.push(this.productions_[t[1]][0]),
                        e.push(w.$),
                        f.push(w._$),
                        z = g[d[d.length - 2]][d[d.length - 1]],
                        d.push(z);
                        break;
                    case 3:
                        return !0
                    }
                }
                return !0
            }
        }
          , b = function() {
            var a = {
                EOF: 1,
                parseError: function(b, c) {
                    if (!this.yy.parseError)
                        throw new Error(b);
                    this.yy.parseError(b, c)
                },
                setInput: function(a) {
                    return this._input = a,
                    this._more = this._less = this.done = !1,
                    this.yylineno = this.yyleng = 0,
                    this.yytext = this.matched = this.match = "",
                    this.conditionStack = ["INITIAL"],
                    this.yylloc = {
                        first_line: 1,
                        first_column: 0,
                        last_line: 1,
                        last_column: 0
                    },
                    this
                },
                input: function() {
                    var a = this._input[0];
                    this.yytext += a,
                    this.yyleng++,
                    this.match += a,
                    this.matched += a;
                    var b = a.match(/\n/);
                    return b && this.yylineno++,
                    this._input = this._input.slice(1),
                    a
                },
                unput: function(a) {
                    return this._input = a + this._input,
                    this
                },
                more: function() {
                    return this._more = !0,
                    this
                },
                less: function(a) {
                    this._input = this.match.slice(a) + this._input
                },
                pastInput: function() {
                    var a = this.matched.substr(0, this.matched.length - this.match.length);
                    return (a.length > 20 ? "..." : "") + a.substr(-20).replace(/\n/g, "")
                },
                upcomingInput: function() {
                    var a = this.match;
                    return a.length < 20 && (a += this._input.substr(0, 20 - a.length)),
                    (a.substr(0, 20) + (a.length > 20 ? "..." : "")).replace(/\n/g, "")
                },
                //换行显示出错的位置---------------------^
                showPosition: function() {
                    var a = this.pastInput()
                      , b = (new Array(a.length + 1)).join("-");
                    return a + this.upcomingInput() + "\n" + b + "^"
                },
                next: function() {
                    if (this.done)
                        return this.EOF;
                    this._input || (this.done = !0);
                    var a, b, c, d, e, f;
                    this._more || (this.yytext = "",
                    this.match = "");
                    var g = this._currentRules();
                    for (var h = 0; h < g.length; h++) {
                        c = this._input.match(this.rules[g[h]]);
                        if (c && (!b || c[0].length > b[0].length)) {
                            b = c,
                            d = h;
                            if (!this.options.flex)
                                break
                        }
                    }
                    if (b) {
                        f = b[0].match(/\n.*/g),
                        f && (this.yylineno += f.length),
                        this.yylloc = {
                            first_line: this.yylloc.last_line,
                            last_line: this.yylineno + 1,
                            first_column: this.yylloc.last_column,
                            last_column: f ? f[f.length - 1].length - 1 : this.yylloc.last_column + b[0].length
                        },
                        this.yytext += b[0],
                        this.match += b[0],
                        this.yyleng = this.yytext.length,
                        this._more = !1,
                        this._input = this._input.slice(b[0].length),
                        this.matched += b[0],
                        a = this.performAction.call(this, this.yy, this, g[d], this.conditionStack[this.conditionStack.length - 1]),
                        this.done && this._input && (this.done = !1);
                        if (a)
                            return a;
                        return
                    }
                    if (this._input === "")
                        return this.EOF;
                    this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
                        text: "",
                        token: null,
                        line: this.yylineno
                    })
                },
                lex: function() {
                    var b = this.next();
                    return typeof b != "undefined" ? b : this.lex()
                },
                begin: function(b) {
                    this.conditionStack.push(b)
                },
                popState: function() {
                    return this.conditionStack.pop()
                },
                _currentRules: function() {
                    return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules
                },
                topState: function() {
                    return this.conditionStack[this.conditionStack.length - 2]
                },
                pushState: function(b) {
                    this.begin(b)
                }
            };
            return a.options = {},
            a.performAction = function(b, c, d, e) {
                var f = e;
                switch (d) {
                case 0:
                    break;
                case 1:
                    return 6;
                case 2:
                    return c.yytext = c.yytext.substr(1, c.yyleng - 2),
                    4;
                case 3:
                    return 17;
                case 4:
                    return 18;
                case 5:
                    return 23;
                case 6:
                    return 24;
                case 7:
                    return 22;
                case 8:
                    return 21;
                case 9:
                    return 10;
                case 10:
                    return 11;
                case 11:
                    return 8;
                case 12:
                    return 14;
                case 13:
                    return "INVALID"
                }
            }
            ,
            a.rules = [/^(?:\s+)/, /^(?:(-?([0-9]|[1-9][0-9]+))(\.[0-9]+)?([eE][-+]?[0-9]+)?\b)/, /^(?:"(?:\\[\\"bfnrt/]|\\u[a-fA-F0-9]{4}|[^\\\0-\x09\x0a-\x1f"])*")/, /^(?:\{)/, /^(?:\})/, /^(?:\[)/, /^(?:\])/, /^(?:,)/, /^(?::)/, /^(?:true\b)/, /^(?:false\b)/, /^(?:null\b)/, /^(?:$)/, /^(?:.)/],
            a.conditions = {
                INITIAL: {
                    rules: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
                    inclusive: !0
                }
            },
            a
        }();
        return a.lexer = b,
        a
    }();
    return typeof a != "undefined" && typeof c != "undefined" && (c.parser = d,
    c.parse = function() {
        return d.parse.apply(d, arguments)
    }
    ,
    c.main = function(d) {
        if (!d[1])
            throw new Error("Usage: " + d[0] + " FILE");
        if (typeof process != "undefined")
            var e = a("fs").readFileSync(a("path").join(process.cwd(), d[1]), "utf8");
        else
            var f = a("file").path(a("file").cwd())
              , e = f.join(d[1]).read({
                charset: "utf-8"
            });
        return c.parser.parse(e)
    }
    ,
    typeof b != "undefined" && a.main === b && c.main(typeof process != "undefined" ? process.argv.slice(1) : a("system").args)),
    c
}();
